/***************************************************************************/
/*                                                                         */
/*  cidparse.c                                                             */
/*                                                                         */
/*    CID-keyed Type1 parser (body).                                       */
/*                                                                         */
/*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009 by       */
/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
/*                                                                         */
/*  This file is part of the FreeType project, and may only be used,       */
/*  modified, and distributed under the terms of the FreeType project      */
/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
/*  this file you indicate that you have read the license and              */
/*  understand and accept it fully.                                        */
/*                                                                         */
/***************************************************************************/


#include <ft2build.h>
#include FT_INTERNAL_DEBUG_H
#include FT_INTERNAL_OBJECTS_H
#include FT_INTERNAL_STREAM_H

#include "cidparse.h"

#include "ciderrs.h"


/*************************************************************************/
/*                                                                       */
/* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
/* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
/* messages during execution.                                            */
/*                                                                       */
#undef  FT_COMPONENT
#define FT_COMPONENT trace_cidparse


/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
/*****                                                               *****/
/*****                    INPUT STREAM PARSER                        *****/
/*****                                                               *****/
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/


FT_LOCAL_DEF(FT_Error)
cid_parser_new(CID_Parser * parser,
               FT_Stream stream,
               FT_Memory memory,
               PSAux_Service psaux)
{
    FT_Error error;
    FT_ULong base_offset, offset, ps_len;
    FT_Byte* cur, * limit;
    FT_Byte* arg1, * arg2;


    FT_MEM_ZERO(parser, sizeof(*parser));
    psaux->ps_parser_funcs->init(&parser->root, 0, 0, memory);

    parser->stream = stream;

    base_offset = FT_STREAM_POS();

    /* first of all, check the font format in the header */
    if (FT_FRAME_ENTER(31))
        goto Exit;

    if (ft_strncmp((char*)stream->cursor,
                   "%!PS-Adobe-3.0 Resource-CIDFont", 31))
    {
        FT_TRACE2(("[not a valid CID-keyed font]\n"));
        error = CID_Err_Unknown_File_Format;
    }

    FT_FRAME_EXIT();
    if (error)
        goto Exit;

Again:
    /* now, read the rest of the file until we find */
    /* `StartData' or `/sfnts'                      */
    {
        FT_Byte buffer[256 + 10];
        FT_Long read_len = 256 + 10; /* same as signed FT_Stream->size */
        FT_Byte* p = buffer;


        for (offset = FT_STREAM_POS();; offset += 256)
        {
            FT_Long stream_len; /* same as signed FT_Stream->size */


            stream_len = stream->size - FT_STREAM_POS();
            if (stream_len == 0)
            {
                FT_TRACE2(("cid_parser_new: no `StartData' keyword found\n"));
                error = CID_Err_Unknown_File_Format;
                goto Exit;
            }

            read_len = FT_MIN(read_len, stream_len);
            if (FT_STREAM_READ(p, read_len))
                goto Exit;

            if (read_len < 256)
                p[read_len] = '\0';

            limit = p + read_len - 10;

            for (p = buffer; p < limit; p++)
            {
                if (p[0] == 'S' && ft_strncmp((char*)p, "StartData", 9) == 0)
                {
                    /* save offset of binary data after `StartData' */
                    offset += p - buffer + 10;
                    goto Found;
                }
                else if (p[1] == 's' && ft_strncmp((char*)p, "/sfnts", 6) == 0)
                {
                    offset += p - buffer + 7;
                    goto Found;
                }
            }

            FT_MEM_MOVE(buffer, p, 10);
            read_len = 256;
            p = buffer + 10;
        }
    }

Found:
    /* We have found the start of the binary data or the `/sfnts' token. */
    /* Now rewind and extract the frame corresponding to this PostScript */
    /* section.                                                          */

    ps_len = offset - base_offset;
    if (FT_STREAM_SEEK(base_offset) ||
        FT_FRAME_EXTRACT(ps_len, parser->postscript))
        goto Exit;

    parser->data_offset = offset;
    parser->postscript_len = ps_len;
    parser->root.base = parser->postscript;
    parser->root.cursor = parser->postscript;
    parser->root.limit = parser->root.cursor + ps_len;
    parser->num_dict = -1;

    /* Finally, we check whether `StartData' or `/sfnts' was real --  */
    /* it could be in a comment or string.  We also get the arguments */
    /* of `StartData' to find out whether the data is represented in  */
    /* binary or hex format.                                          */

    arg1 = parser->root.cursor;
    cid_parser_skip_PS_token(parser);
    cid_parser_skip_spaces(parser);
    arg2 = parser->root.cursor;
    cid_parser_skip_PS_token(parser);
    cid_parser_skip_spaces(parser);

    limit = parser->root.limit;
    cur = parser->root.cursor;

    while (cur < limit)
    {
        if (parser->root.error)
        {
            error = parser->root.error;
            goto Exit;
        }

        if (cur[0] == 'S' && ft_strncmp((char*)cur, "StartData", 9) == 0)
        {
            if (ft_strncmp((char*)arg1, "(Hex)", 5) == 0)
                parser->binary_length = ft_atol((const char*)arg2);

            limit = parser->root.limit;
            cur = parser->root.cursor;
            goto Exit;
        }
        else if (cur[1] == 's' && ft_strncmp((char*)cur, "/sfnts", 6) == 0)
        {
            FT_TRACE2(("cid_parser_new: cannot handle Type 11 fonts\n"));
            error = CID_Err_Unknown_File_Format;
            goto Exit;
        }

        cid_parser_skip_PS_token(parser);
        cid_parser_skip_spaces(parser);
        arg1 = arg2;
        arg2 = cur;
        cur = parser->root.cursor;
    }

    /* we haven't found the correct `StartData'; go back and continue */
    /* searching                                                      */
    FT_FRAME_RELEASE(parser->postscript);
    if (!FT_STREAM_SEEK(offset))
        goto Again;

Exit:
    return error;
}


FT_LOCAL_DEF(void)
cid_parser_done(CID_Parser * parser)
{
    /* always free the private dictionary */
    if (parser->postscript)
    {
        FT_Stream stream = parser->stream;


        FT_FRAME_RELEASE(parser->postscript);
    }
    parser->root.funcs.done(&parser->root);
}


/* END */